﻿using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.NetworkInformation;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Xml.Serialization;
using Microsoft.Win32;

namespace ComTools
{
    public sealed class UtilityHelper
    {
        public static String RunDos(String cmd)
        {
            Process p = new Process();
            ProcessStartInfo pi = new ProcessStartInfo();
            pi.FileName = "cmd.exe";
            pi.Arguments = "/c " + cmd;
            pi.UseShellExecute = false;
            pi.RedirectStandardInput = true;
            pi.RedirectStandardOutput = true;
            pi.RedirectStandardError = false;
            pi.CreateNoWindow = true;
            p.StartInfo = pi;
            string strOutput = String.Empty;
            try
            {
                p.Start();
                //p.StandardInput.WriteLine(cmd); //写入要执行的命令 可以多条写入也可以复合命令写入
                //p.StandardInput.WriteLine("D:");
                //p.StandardInput.WriteLine("npm run build");
                //p.StandardInput.WriteLine("exit");
                strOutput = p.StandardOutput.ReadToEnd();
                p.WaitForExit();
                p.Close();
            }
            catch (Exception e)
            {
                //异常处理
            }
            //
            return strOutput;
        }

        /// <param name="iFrequency">声音频率（从37Hz到32767Hz）。在windows95中忽略</param>
        /// <param name="iDuration">声音的持续时间，以毫秒为单位。</param>
        [DllImport("Kernel32.dll")] //引入命名空间 using System.Runtime.InteropServices;
        public static extern bool Beep(int frequency = 800, int duration = 200);


        public static void DataGridViewRowPostPaint(object sender, DataGridViewRowPostPaintEventArgs e)
        {
            DataGridView dataGridView = sender as DataGridView;
            if (dataGridView == null) { return; }
            var rowIdx = (e.RowIndex + 1).ToString(System.Globalization.CultureInfo.CurrentCulture);
            using (var centerFormat = new StringFormat())
            {
                centerFormat.Alignment = StringAlignment.Center;
                centerFormat.LineAlignment = StringAlignment.Center;

                var headerBounds = new Rectangle(e.RowBounds.Left, e.RowBounds.Top, dataGridView.RowHeadersWidth, e.RowBounds.Height);
                e.Graphics.DrawString(rowIdx, dataGridView.Font, SystemBrushes.ControlText, headerBounds, centerFormat);
            };
        }

        public static bool IsValidIP(string ip)
        {
            if (System.Text.RegularExpressions.Regex.IsMatch(ip, @"^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"))
            {
                string[] ips = ip.Split('.');
                if (ips.Length == 4 || ips.Length == 6)
                {
                    if (System.Int32.Parse(ips[0]) < 256 && System.Int32.Parse(ips[1]) < 256 & System.Int32.Parse(ips[2]) < 256 & System.Int32.Parse(ips[3]) < 256)
                        return true;
                    else
                        return false;
                }
                else
                {
                    return false;
                }
            }
            else
                return false;
        }

        public static byte[] Hex2Bytes(string hex)
        {
            if (hex == null)
            {
                return new byte[0];
            }
            hex = hex.Replace("-", "").Replace(" ", "").Trim();
            if (hex.Length % 2 != 0)
            {
                hex += "0";
            }
            byte[] vs = new byte[hex.Length / 2];
            for (int i = 0; i < vs.Length; i++)
            {
                vs[i] = Convert.ToByte(hex.Substring(i * 2, 2), 16);
            }
            return vs;
        }

        public static string Bytes2Hex(byte[] bytes)
        {
            return BitConverter.ToString(bytes);
        }

        public static string GetVersionFromRegistry()
        {
            StringBuilder sbResult = new StringBuilder();
            // Opens the registry key for the .NET Framework entry.
            using (RegistryKey ndpKey =
                    RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).
                    OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\"))
            {
                foreach (var versionKeyName in ndpKey.GetSubKeyNames())
                {
                    // Skip .NET Framework 4.5 version information.
                    //if (versionKeyName == "v4")
                    //{
                    //    continue;
                    //}

                    if (versionKeyName.StartsWith("v"))
                    {

                        RegistryKey versionKey = ndpKey.OpenSubKey(versionKeyName);
                        // Get the .NET Framework version value.
                        var name = (string)versionKey.GetValue("Version", "");
                        // Get the service pack (SP) number.
                        var sp = versionKey.GetValue("SP", "").ToString();

                        // Get the installation flag, or an empty string if there is none.
                        var install = versionKey.GetValue("Install", "").ToString();
                        if (string.IsNullOrEmpty(install)) // No install info; it must be in a child subkey.
                        {
                            sbResult.AppendLine($"{versionKeyName}  {name}");
                        }
                        else
                        {
                            if (!(string.IsNullOrEmpty(sp)) && install == "1")
                            {
                                sbResult.AppendLine($"{versionKeyName}  {name}  SP{sp}");
                            }
                        }
                        if (!string.IsNullOrEmpty(name))
                        {
                            continue;
                        }
                        foreach (var subKeyName in versionKey.GetSubKeyNames())
                        {
                            RegistryKey subKey = versionKey.OpenSubKey(subKeyName);
                            name = (string)subKey.GetValue("Version", "");
                            if (!string.IsNullOrEmpty(name))
                                sp = subKey.GetValue("SP", "").ToString();

                            install = subKey.GetValue("Install", "").ToString();
                            if (string.IsNullOrEmpty(install)) //No install info; it must be later.
                            {
                                sbResult.AppendLine($"{versionKeyName}  {name}");
                            }
                            else
                            {
                                if (!(string.IsNullOrEmpty(sp)) && install == "1")
                                {
                                    sbResult.AppendLine($"{subKeyName}  {name}  SP{sp}");
                                }
                                else if (install == "1")
                                {
                                    sbResult.AppendLine($"  {subKeyName}  {name}");
                                }
                            }
                        }
                    }
                }
            }
            //
            return sbResult.ToString();
        }

        public static string GetVersionFromAssembly()
        {
            string v = FileVersionInfo.GetVersionInfo(typeof(Uri).Assembly.Location).ProductVersion;
            return v;
        }

        #region 检查是否为IP地址
        /// <summary>
        /// 是否为ip
        /// </summary>
        /// <param name="ip"></param>
        /// <returns></returns>
        public static bool IsIP(string ip)
        {
            return Regex.IsMatch(ip, @"^((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)$");
        }
        #endregion

        #region 检查网络是否连通

        [DllImport("wininet.dll")]
        private extern static bool InternetGetConnectedState(int Description, int ReservedValue);

        /// <summary>
        /// 用于检查网络是否可以连接互联网,true表示连接成功,false表示连接失败 
        /// </summary>
        /// <returns></returns>
        public static bool IsConnectInternet()
        {
            int Description = 0;
            return InternetGetConnectedState(Description, 0);
        }

        /// <summary>
        /// 用于检查IP地址或域名是否可以使用TCP/IP协议访问(使用Ping命令),true表示Ping成功,false表示Ping失败 
        /// </summary>
        /// <param name="strIpOrDName">输入参数,表示IP地址或域名</param>
        /// <returns></returns>
        public static bool PingIpOrDomainName(string strIpOrDName)
        {
            try
            {
                Ping objPingSender = new Ping();
                PingOptions objPinOptions = new PingOptions();
                objPinOptions.DontFragment = true;
                string data = "";
                byte[] buffer = Encoding.UTF8.GetBytes(data);
                int intTimeout = 100;
                //PingReply objPinReply = objPingSender.Send(strIpOrDName, intTimeout, buffer, objPinOptions);
                PingReply objPinReply = objPingSender.Send(strIpOrDName.Trim(), intTimeout, buffer);

                if (objPinReply.Status == IPStatus.Success)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception)
            {
                return false;
            }
        }

        #endregion

        #region 是否为数字的判断

        public static bool IsNumeric(string value)
        {
            return Regex.IsMatch(value, @"^[+-]?\d*[.]?\d*$");
        }
        public static bool IsInt(string value)
        {
            return Regex.IsMatch(value, @"^[+-]?\d*$");
        }
        public static bool IsUnsign(string value)
        {
            return Regex.IsMatch(value, @"^\d*[.]?\d*$");
        }

        public static bool isTel(string strInput)
        {
            return Regex.IsMatch(strInput, @"\d{3}-\d{8}|\d{4}-\d{7}");
        }

        #endregion

        #region Thread.Sleep

        System.Threading.Timer TimerSleep = null;
        AutoResetEvent autoResetEvent = new AutoResetEvent(true);

        public void SleepMilliseconds(int milliSeconds)
        {
            if (TimerSleep == null)
            {
                TimerSleep = new System.Threading.Timer(new TimerCallback((obj) =>
                {
                    AutoResetEvent xx = obj as AutoResetEvent;
                    xx.Set();
                }), autoResetEvent, Timeout.Infinite, Timeout.Infinite);
            }

            autoResetEvent.Reset();
            TimerSleep.Change(milliSeconds, Timeout.Infinite);
            autoResetEvent.WaitOne(milliSeconds);
        }

        #endregion 

        public static string HttGet(string url, Dictionary<string, string> content)
        {
            try
            {
                string queryUrl = string.Empty;
                if (content != null && content.Count > 0)
                {
                    StringBuilder data = new StringBuilder();
                    foreach (var kp in content.Keys)
                    {
                        if (data.Length > 0)
                        {
                            data.Append("=");
                        }
                        data.Append($"{kp}={content[kp]}");
                    }
                    queryUrl = url + "?" + data.ToString();
                }
                HttpWebRequest request = WebRequest.CreateHttp(queryUrl);
                request.Method = "get";

                WebResponse response = request.GetResponse();
                System.IO.Stream stream = response.GetResponseStream();
                byte[] byteResp = new byte[stream.Length];
                stream.Read(byteResp, 0, byteResp.Length);
                var r = System.Text.Encoding.UTF8.GetString(byteResp);
                return r;
            }
            catch (Exception exc)
            {
                return "";
            }
        }

        public static string HttPost(string url, Dictionary<string, string> content)
        {
            HttpWebRequest request = WebRequest.CreateHttp(url);
            request.Method = "post";
            request.ContentType = "application/x-www-form-urlencoded";
            if (content != null && content.Count > 0)
            {
                StringBuilder data = new StringBuilder();
                foreach (var kp in content.Keys)
                {
                    if (data.Length > 0)
                    {
                        data.Append("=");
                    }
                    data.Append($"{kp}={content[kp]}");
                }
                byte[] requestContent = System.Text.Encoding.UTF8.GetBytes(data.ToString());
                System.IO.Stream rqstream = request.GetRequestStream();
                rqstream.Write(requestContent, 0, requestContent.Length);
                rqstream.Close();
            }
            using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
            {
                using (System.IO.StreamReader rsstream = new StreamReader(response.GetResponseStream()))
                {
                    var r = rsstream.ReadToEnd();
                    rsstream.Close();
                    return r;
                }
            }
        }

        static ushort[] CRCTab16 = new ushort[256]
        {
            0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
            0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
            0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
            0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
            0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
            0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
            0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
            0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
            0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
            0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
            0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
            0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
            0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
            0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
            0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
            0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
            0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
            0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
            0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
            0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
            0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
            0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
            0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
            0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
            0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
            0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
            0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
            0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
            0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
            0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
            0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
            0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
        };
        /// <summary>
        /// CRC数据校验
        /// </summary>
        /// <param name="pDataIn"></param>
        /// <param name="iLenIn"></param>
        /// <param name="pCRCOut"></param>
        /// <param name="iCRCLen"></param>
        /// <returns></returns>
        public static bool CRC16CheckSum(byte[] pDataIn, int iLenIn, byte[] pCRCOut, int iCRCLen)
        {
            ushort dwCRCResult = 0; // CRC值

            if (iCRCLen < 2)
            {
                return false;
            }

            for (int i = 0; i < iLenIn; i++)
                dwCRCResult = (ushort)((dwCRCResult << 8) ^ CRCTab16[(dwCRCResult >> 8) ^ pDataIn[i]]);

            pCRCOut[0] = (byte)(dwCRCResult & 0xff);
            pCRCOut[1] = (byte)((dwCRCResult >> 8) & 0xff);

            iCRCLen = 2;

            return true;
        }

        #region XML序列化

        public static void SaveToXml(string filePath, object sourceObj, Type type, string xmlRootName)
        {
            if (!string.IsNullOrWhiteSpace(filePath) && sourceObj != null)
            {
                type = type != null ? type : sourceObj.GetType();

                using (StreamWriter writer = new StreamWriter(filePath))
                {
                    System.Xml.Serialization.XmlSerializer xmlSerializer = string.IsNullOrWhiteSpace(xmlRootName) ?
                        new System.Xml.Serialization.XmlSerializer(type) :
                        new System.Xml.Serialization.XmlSerializer(type, new XmlRootAttribute(xmlRootName));
                    xmlSerializer.Serialize(writer, sourceObj);                    
                }
                using (MemoryStream ms = new MemoryStream())
                {
                    XmlSerializer xmlSerializer = new XmlSerializer(type);
                    xmlSerializer.Serialize(ms, sourceObj);
                }
            }
        }

        public static string Convert2Xml(object obj)
        {
            using(MemoryStream ms = new MemoryStream())
            {
                XmlSerializer xmlSerializer = new XmlSerializer(obj.GetType());
                xmlSerializer.Serialize(ms, obj);
                ms.ToArray();
                using (StreamReader reader = new StreamReader(ms))
                {
                    string xx = reader.ReadToEnd();
                    return xx;
                }
            }
        }

        public static object LoadFromXml(string filePath, Type type)
        {
            object result = null;

            if (File.Exists(filePath))
            {
                using (StreamReader reader = new StreamReader(filePath))
                {
                    System.Xml.Serialization.XmlSerializer xmlSerializer = new System.Xml.Serialization.XmlSerializer(type);
                    result = xmlSerializer.Deserialize(reader);
                }
            }

            return result;
        }

        #endregion

        #region 对象序列化

        public byte[] data2bytes(object obj)
        {
            BinaryFormatter binFormat = new BinaryFormatter();//创建二进制序列化器
            MemoryStream ms = new MemoryStream();
            binFormat.Serialize(ms, obj);
            var bytes = ms.ToArray();
            ms.Close();
            return bytes;
        }

        public object bytes2data(byte[] bytes)
        {
            MemoryStream ms = new MemoryStream(bytes);
            BinaryFormatter binFormat = new BinaryFormatter();//创建二进制序列化器
            object obj = binFormat.Deserialize(ms);
            ms.Close();
            return obj;
        }

        #endregion

        #region 加密解密
        static byte[] iv = new byte[16];
        static byte[] key = new byte[32];
        public static void GetDBConn()
        {
            if (!File.Exists("./db.db"))
            {
                init();
            }
            var bytes = File.ReadAllBytes("./db.db");
            if (bytes.Length <= 48)
            {
                return;
            }
            Array.Copy(bytes, key, 32);
            Array.Copy(bytes, 32, iv, 0, 16);
            var data = new byte[bytes.Length - 48];
            var xx = AesDecrypt(data, key, iv);
        }

        public static void init()
        {
            System.Security.Cryptography.RijndaelManaged rij = new System.Security.Cryptography.RijndaelManaged();
            rij.GenerateKey();
            rij.GenerateIV();

            //var key = Encoding.UTF8.GetString(rij.Key);
            //var iv = Encoding.UTF8.GetString(rij.IV);

            key = rij.Key;
            iv = rij.IV;

            var e = Encoding.UTF8.GetBytes("");

            var r = AesEncrypt(e, key, iv);

            byte[] yy = new byte[r.Length + key.Length + iv.Length];

            Array.Copy(key, yy, key.Length);
            Array.Copy(iv, 0, yy, key.Length, iv.Length);
            Array.Copy(r, 0, yy, key.Length + iv.Length, r.Length);
            //return key + iv;
            File.WriteAllBytes("./db.db", yy);
        }

        private static byte[] GetKey()
        {
            return Convert.FromBase64String("hNkdJqUojY79j1hdfaCy/rrdcz+Zb7BecfIRLETHtqc=");
        }

        private static byte[] GetIV()
        {
            return Convert.FromBase64String("dHqsKRvx6XDWSRbePghlSQ==");
        }

        /// <summary>
        ///  AES 加密
        /// </summary>
        /// <param name="str">明文（待加密）</param>
        /// <param name="key">密文</param>
        /// <returns></returns>
        public static string AesEncrypt(string str, string key = null)
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);

            System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged();

            rm.Mode = System.Security.Cryptography.CipherMode.ECB;
            rm.Padding = System.Security.Cryptography.PaddingMode.PKCS7;

            if (string.IsNullOrEmpty(key))
            {
                rm.Key = GetKey();
            }
            else
            {
                rm.Key = Encoding.UTF8.GetBytes(key);
            }
            rm.IV = GetIV();

            System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateEncryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return Convert.ToBase64String(resultArray, 0, resultArray.Length);
        }
        /// <summary>
        ///  AES 解密
        /// </summary>
        /// <param name="str">明文（待解密）</param>
        /// <param name="key">密文</param>
        /// <returns></returns>
        public static string AesDecrypt(string str, string key = null)
        {
            if (string.IsNullOrEmpty(str)) return null;

            try
            {
                Byte[] toEncryptArray = Convert.FromBase64String(str);
                System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged ();
                rm.Mode = System.Security.Cryptography.CipherMode.ECB;
                rm.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
                if (string.IsNullOrEmpty(key))
                {
                    rm.Key = GetKey();
                }
                else
                {
                    rm.Key = Encoding.UTF8.GetBytes(key);
                }
                rm.IV = GetIV();

                System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateDecryptor();
                Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

                return Encoding.UTF8.GetString(resultArray);
            }
            catch (Exception exc)
            {
                return null;
            }
        }

        /// <summary>
        ///  AES 加密
        /// </summary>
        /// <param name="str">明文（待加密）</param>
        /// <returns></returns>
        public static byte[] AesEncrypt(byte[] toEncryptArray, byte[] key, byte[] iv)
        {
            System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged();

            rm.Mode = System.Security.Cryptography.CipherMode.ECB;
            rm.Padding = System.Security.Cryptography.PaddingMode.PKCS7;

            rm.Key = key;
            rm.IV = iv;

            System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateEncryptor();
            byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return resultArray;
        }
        /// <summary>
        ///  AES 解密
        /// </summary>
        /// <param name="str">明文（待解密）</param>
        /// <returns></returns>
        public static byte[] AesDecrypt(byte[] toEncryptArray, byte[] key, byte[] iv)
        {
            try
            {
                System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged();
                rm.Mode = System.Security.Cryptography.CipherMode.ECB;
                rm.Padding = System.Security.Cryptography.PaddingMode.PKCS7;

                rm.Key = key;
                rm.IV = iv;

                System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateDecryptor();
                byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

                return resultArray;
            }
            catch (Exception exc)
            {
                return null;
            }
        }

        #endregion
    }
}